﻿using UIKit;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.Globalization;
using System.Collections.Generic;

namespace WPFUIKit.Test
{
    
    
    /// <summary>
    ///This is a test class for NSBundleTest and is intended
    ///to contain all NSBundleTest Unit Tests
    ///</summary>
    [TestClass()]
    public class NSBundleTest
    {


        private TestContext testContextInstance;

        /// <summary>
        ///Gets or sets the test context which provides
        ///information about and functionality for the current test run.
        ///</summary>
        public TestContext TestContext
        {
            get
            {
                return testContextInstance;
            }
            set
            {
                testContextInstance = value;
            }
        }

        #region Additional test attributes
        // 
        //You can use the following additional attributes as you write your tests:
        //
        //Use ClassInitialize to run code before running the first test in the class
        //[ClassInitialize()]
        //public static void MyClassInitialize(TestContext testContext)
        //{
        //}
        //
        //Use ClassCleanup to run code after all tests in a class have run
        //[ClassCleanup()]
        //public static void MyClassCleanup()
        //{
        //}
        //
        //Use TestInitialize to run code before running each test
        //[TestInitialize()]
        //public void MyTestInitialize()
        //{
        //}
        //
        //Use TestCleanup to run code after each test has run
        //[TestCleanup()]
        //public void MyTestCleanup()
        //{
        //}
        //
        #endregion


        /// <summary>
        ///A test for unload
        ///</summary>
        [TestMethod()]
        public void unloadTest()
        {
            NSBundle target = new NSBundle(); // TODO: Initialize to an appropriate value
            bool expected = false; // TODO: Initialize to an appropriate value
            bool actual;
            actual = target.unload();
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for sharedSupportPath
        ///</summary>
        [TestMethod()]
        public void sharedSupportPathTest()
        {
            NSBundle target = new NSBundle(); // TODO: Initialize to an appropriate value
            string expected = string.Empty; // TODO: Initialize to an appropriate value
            string actual;
            actual = target.sharedSupportPath();
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for sharedFrameworksPath
        ///</summary>
        [TestMethod()]
        public void sharedFrameworksPathTest()
        {
            NSBundle target = new NSBundle(); // TODO: Initialize to an appropriate value
            string expected = string.Empty; // TODO: Initialize to an appropriate value
            string actual;
            actual = target.sharedFrameworksPath();
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for setBundleIdentifier
        ///</summary>
        [TestMethod()]
        public void setBundleIdentifierTest()
        {
            NSBundle target = new NSBundle(); // TODO: Initialize to an appropriate value
            string identifier = string.Empty; // TODO: Initialize to an appropriate value
            target.setBundleIdentifier(identifier);
            Assert.Inconclusive("A method that does not return a value cannot be verified.");
        }

        /// <summary>
        ///A test for resourcePath
        ///</summary>
        [TestMethod()]
        public void resourcePathTest()
        {
            NSBundle target = new NSBundle(); // TODO: Initialize to an appropriate value
            string expected = string.Empty; // TODO: Initialize to an appropriate value
            string actual;
            actual = target.resourcePath();
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for privateFrameworksPath
        ///</summary>
        [TestMethod()]
        public void privateFrameworksPathTest()
        {
            NSBundle target = new NSBundle(); // TODO: Initialize to an appropriate value
            string expected = string.Empty; // TODO: Initialize to an appropriate value
            string actual;
            actual = target.privateFrameworksPath();
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for principalClass
        ///</summary>
        [TestMethod()]
        public void principalClassTest()
        {
            NSBundle target = new NSBundle(); // TODO: Initialize to an appropriate value
            Type expected = null; // TODO: Initialize to an appropriate value
            Type actual;
            actual = target.principalClass();
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for preflightAndReturnError
        ///</summary>
        [TestMethod()]
        public void preflightAndReturnErrorTest()
        {
            NSBundle target = new NSBundle(); // TODO: Initialize to an appropriate value
            Exception error = null; // TODO: Initialize to an appropriate value
            Exception errorExpected = null; // TODO: Initialize to an appropriate value
            bool expected = false; // TODO: Initialize to an appropriate value
            bool actual;
            actual = target.preflightAndReturnError(out error);
            Assert.AreEqual(errorExpected, error);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for preferredLocalizationsFromArray
        ///</summary>
        [TestMethod()]
        public void preferredLocalizationsFromArrayTest1()
        {
            string[] localizationsArray = null; // TODO: Initialize to an appropriate value
            string[] preferencesArray = null; // TODO: Initialize to an appropriate value
            string expected = string.Empty; // TODO: Initialize to an appropriate value
            string actual;
            actual = NSBundle.preferredLocalizationsFromArray(localizationsArray, preferencesArray);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for preferredLocalizationsFromArray
        ///</summary>
        [TestMethod()]
        public void preferredLocalizationsFromArrayTest()
        {
            string[] localizationsArray = null; // TODO: Initialize to an appropriate value
            string[] expected = null; // TODO: Initialize to an appropriate value
            string[] actual;
            actual = NSBundle.preferredLocalizationsFromArray(localizationsArray);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for preferredLocalizations
        ///</summary>
        [TestMethod()]
        public void preferredLocalizationsTest()
        {
            NSBundle target = new NSBundle(); // TODO: Initialize to an appropriate value
            string[] expected = null; // TODO: Initialize to an appropriate value
            string[] actual;
            actual = target.preferredLocalizations();
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for pathsForResourcesOfType
        ///</summary>
        [TestMethod()]
        public void pathsForResourcesOfTypeTest1()
        {
            NSBundle target = new NSBundle(); // TODO: Initialize to an appropriate value
            string extension = string.Empty; // TODO: Initialize to an appropriate value
            string subPath = string.Empty; // TODO: Initialize to an appropriate value
            string[] expected = null; // TODO: Initialize to an appropriate value
            string[] actual;
            actual = target.pathsForResourcesOfType(extension, subPath);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for pathsForResourcesOfType
        ///</summary>
        [TestMethod()]
        public void pathsForResourcesOfTypeTest()
        {
            NSBundle target = new NSBundle(); // TODO: Initialize to an appropriate value
            string extension = string.Empty; // TODO: Initialize to an appropriate value
            string subPath = string.Empty; // TODO: Initialize to an appropriate value
            string localizationName = string.Empty; // TODO: Initialize to an appropriate value
            string[] expected = null; // TODO: Initialize to an appropriate value
            string[] actual;
            actual = target.pathsForResourcesOfType(extension, subPath, localizationName);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for pathForResource
        ///</summary>
        [TestMethod()]
        public void pathForResourceTest2()
        {
            NSBundle target = new NSBundle(); // TODO: Initialize to an appropriate value
            string name = string.Empty; // TODO: Initialize to an appropriate value
            string extension = string.Empty; // TODO: Initialize to an appropriate value
            string expected = string.Empty; // TODO: Initialize to an appropriate value
            string actual;
            actual = target.pathForResource(name, extension);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for pathForResource
        ///</summary>
        [TestMethod()]
        public void pathForResourceTest1()
        {
            NSBundle target = new NSBundle(); // TODO: Initialize to an appropriate value
            string name = string.Empty; // TODO: Initialize to an appropriate value
            string extension = string.Empty; // TODO: Initialize to an appropriate value
            string subPath = string.Empty; // TODO: Initialize to an appropriate value
            string expected = string.Empty; // TODO: Initialize to an appropriate value
            string actual;
            actual = target.pathForResource(name, extension, subPath);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for pathForResource
        ///</summary>
        [TestMethod()]
        public void pathForResourceTest()
        {
            NSBundle target = new NSBundle(); // TODO: Initialize to an appropriate value
            string name = string.Empty; // TODO: Initialize to an appropriate value
            string extension = string.Empty; // TODO: Initialize to an appropriate value
            string subPath = string.Empty; // TODO: Initialize to an appropriate value
            string localizationName = string.Empty; // TODO: Initialize to an appropriate value
            string expected = string.Empty; // TODO: Initialize to an appropriate value
            string actual;
            actual = target.pathForResource(name, extension, subPath, localizationName);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for pathForAuxiliaryExecutable
        ///</summary>
        [TestMethod()]
        public void pathForAuxiliaryExecutableTest()
        {
            NSBundle target = new NSBundle(); // TODO: Initialize to an appropriate value
            string executableName = string.Empty; // TODO: Initialize to an appropriate value
            string expected = string.Empty; // TODO: Initialize to an appropriate value
            string actual;
            actual = target.pathForAuxiliaryExecutable(executableName);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for objectForInfoDictionaryKey
        ///</summary>
        [TestMethod()]
        public void objectForInfoDictionaryKeyTest()
        {
            NSBundle target = new NSBundle(); // TODO: Initialize to an appropriate value
            string key = string.Empty; // TODO: Initialize to an appropriate value
            object expected = null; // TODO: Initialize to an appropriate value
            object actual;
            actual = target.objectForInfoDictionaryKey(key);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for mainBundle
        ///</summary>
        [TestMethod()]
        public void mainBundleTest()
        {
            NSBundle expected = null; // TODO: Initialize to an appropriate value
            NSBundle actual;
            actual = NSBundle.mainBundle();
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for localizedStringForKey
        ///</summary>
        [TestMethod()]
        public void localizedStringForKeyTest()
        {
            NSBundle target = new NSBundle(); // TODO: Initialize to an appropriate value
            string key = string.Empty; // TODO: Initialize to an appropriate value
            string value = string.Empty; // TODO: Initialize to an appropriate value
            string tableName = string.Empty; // TODO: Initialize to an appropriate value
            string expected = string.Empty; // TODO: Initialize to an appropriate value
            string actual;
            actual = target.localizedStringForKey(key, value, tableName);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for localizedInfoDictionary
        ///</summary>
        [TestMethod()]
        public void localizedInfoDictionaryTest()
        {
            NSBundle target = new NSBundle(); // TODO: Initialize to an appropriate value
            Dictionary<string, string> expected = null; // TODO: Initialize to an appropriate value
            Dictionary<string, string> actual;
            actual = target.localizedInfoDictionary();
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for localizations
        ///</summary>
        [TestMethod()]
        public void localizationsTest()
        {
            NSBundle target = new NSBundle(); // TODO: Initialize to an appropriate value
            string[] expected = null; // TODO: Initialize to an appropriate value
            string[] actual;
            actual = target.localizations();
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for loadNibNamed
        ///</summary>
        [TestMethod()]
        public void loadNibNamedTest()
        {
            NSBundle target = new NSBundle(); // TODO: Initialize to an appropriate value
            string name = string.Empty; // TODO: Initialize to an appropriate value
            object owner = null; // TODO: Initialize to an appropriate value
            Dictionary<object, object> options = null; // TODO: Initialize to an appropriate value
            object[] expected = null; // TODO: Initialize to an appropriate value
            object[] actual;
            actual = target.loadNibNamed(name, owner, options);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for loadAndReturnError
        ///</summary>
        [TestMethod()]
        public void loadAndReturnErrorTest()
        {
            NSBundle target = new NSBundle(); // TODO: Initialize to an appropriate value
            Exception error = null; // TODO: Initialize to an appropriate value
            Exception errorExpected = null; // TODO: Initialize to an appropriate value
            bool expected = false; // TODO: Initialize to an appropriate value
            bool actual;
            actual = target.loadAndReturnError(out error);
            Assert.AreEqual(errorExpected, error);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for load
        ///</summary>
        [TestMethod()]
        public void loadTest()
        {
            NSBundle target = new NSBundle(); // TODO: Initialize to an appropriate value
            bool expected = false; // TODO: Initialize to an appropriate value
            bool actual;
            actual = target.load();
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for isLoaded
        ///</summary>
        [TestMethod()]
        public void isLoadedTest()
        {
            NSBundle target = new NSBundle(); // TODO: Initialize to an appropriate value
            bool expected = false; // TODO: Initialize to an appropriate value
            bool actual;
            actual = target.isLoaded();
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for initWithPath
        ///</summary>
        [TestMethod()]
        public void initWithPathTest()
        {
            NSBundle target = new NSBundle(); // TODO: Initialize to an appropriate value
            string fullPath = string.Empty; // TODO: Initialize to an appropriate value
            object expected = null; // TODO: Initialize to an appropriate value
            object actual;
            actual = target.initWithPath(fullPath);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for infoDictionary
        ///</summary>
        [TestMethod()]
        public void infoDictionaryTest()
        {
            NSBundle target = new NSBundle(); // TODO: Initialize to an appropriate value
            Dictionary<object, object> expected = null; // TODO: Initialize to an appropriate value
            Dictionary<object, object> actual;
            actual = target.infoDictionary();
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for executablePath
        ///</summary>
        [TestMethod()]
        public void executablePathTest()
        {
            NSBundle target = new NSBundle(); // TODO: Initialize to an appropriate value
            string expected = string.Empty; // TODO: Initialize to an appropriate value
            string actual;
            actual = target.executablePath();
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for executableArchitectures
        ///</summary>
        [TestMethod()]
        public void executableArchitecturesTest()
        {
            NSBundle target = new NSBundle(); // TODO: Initialize to an appropriate value
            int[] expected = null; // TODO: Initialize to an appropriate value
            int[] actual;
            actual = target.executableArchitectures();
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for developmentLocalization
        ///</summary>
        [TestMethod()]
        public void developmentLocalizationTest()
        {
            NSBundle target = new NSBundle(); // TODO: Initialize to an appropriate value
            CultureInfo expected = null; // TODO: Initialize to an appropriate value
            CultureInfo actual;
            actual = target.developmentLocalization();
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for classNamed
        ///</summary>
        [TestMethod()]
        public void classNamedTest()
        {
            NSBundle target = new NSBundle(); // TODO: Initialize to an appropriate value
            string className = string.Empty; // TODO: Initialize to an appropriate value
            Type expected = null; // TODO: Initialize to an appropriate value
            Type actual;
            actual = target.classNamed(className);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for bundleWithPath
        ///</summary>
        [TestMethod()]
        public void bundleWithPathTest()
        {
            string fullPath = string.Empty; // TODO: Initialize to an appropriate value
            NSBundle expected = null; // TODO: Initialize to an appropriate value
            NSBundle actual;
            actual = NSBundle.bundleWithPath(fullPath);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for bundleWithIdentifier
        ///</summary>
        [TestMethod()]
        public void bundleWithIdentifierTest()
        {
            string identifier = string.Empty; // TODO: Initialize to an appropriate value
            NSBundle expected = null; // TODO: Initialize to an appropriate value
            NSBundle actual;
            actual = NSBundle.bundleWithIdentifier(identifier);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for bundlePath
        ///</summary>
        [TestMethod()]
        public void bundlePathTest()
        {
            NSBundle target = new NSBundle(); // TODO: Initialize to an appropriate value
            string expected = string.Empty; // TODO: Initialize to an appropriate value
            string actual;
            actual = target.bundlePath();
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for bundleIdentifier
        ///</summary>
        [TestMethod()]
        public void bundleIdentifierTest()
        {
            NSBundle target = new NSBundle(); // TODO: Initialize to an appropriate value
            string expected = string.Empty; // TODO: Initialize to an appropriate value
            string actual;
            actual = target.bundleIdentifier();
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for bundleForClass
        ///</summary>
        [TestMethod()]
        public void bundleForClassTest()
        {
            Type aClass = null; // TODO: Initialize to an appropriate value
            NSBundle expected = null; // TODO: Initialize to an appropriate value
            NSBundle actual;
            actual = NSBundle.bundleForClass(aClass);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for builtInPlugInsPath
        ///</summary>
        [TestMethod()]
        public void builtInPlugInsPathTest()
        {
            NSBundle target = new NSBundle(); // TODO: Initialize to an appropriate value
            string expected = string.Empty; // TODO: Initialize to an appropriate value
            string actual;
            actual = target.builtInPlugInsPath();
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for allFrameworks
        ///</summary>
        [TestMethod()]
        public void allFrameworksTest()
        {
            NSBundle[] expected = null; // TODO: Initialize to an appropriate value
            NSBundle[] actual;
            actual = NSBundle.allFrameworks();
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for allBundles
        ///</summary>
        [TestMethod()]
        public void allBundlesTest()
        {
            NSBundle[] expected = null; // TODO: Initialize to an appropriate value
            NSBundle[] actual;
            actual = NSBundle.allBundles();
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for NSBundle Constructor
        ///</summary>
        [TestMethod()]
        public void NSBundleConstructorTest()
        {
            NSBundle target = new NSBundle();
            Assert.Inconclusive("TODO: Implement code to verify target");
        }
    }
}
